package 炫彩元素类

import (
	xc "gitee.com/go_888/xcgui/xcgui/xc"
	xcc "gitee.com/go_888/xcgui/xcgui/xcc"
)

// X结构_列表树 列表树元素.
type X结构_列表树 struct {
	X结构_滚动视图
}

// 列表树_创建, 创建树元素.
//
// x: 元素x坐标.
//
// y: 元素y坐标.
//
// cx: 宽度.
//
// cy: 高度.
//
// hParent: 父是窗口资源句柄或UI元素资源句柄. 如果是窗口资源句柄将被添加到窗口, 如果是元素资源句柄将被添加到元素.
func X创建列表树(元素x坐标, 元素y坐标, 宽度, 高度 int32, 父窗口句柄 int) *X结构_列表树 {
	p := &X结构_列表树{}
	p.X设置句柄(xc.X列表树_创建(元素x坐标, 元素y坐标, 宽度, 高度, 父窗口句柄))
	return p
}

// 列表树_创建Ex, 创建树元素, 使用内置项模板, 自动创建数据适配器.
//
// x: 元素x坐标.
//
// y: 元素y坐标.
//
// cx: 宽度.
//
// cy: 高度.
//
// hParent: 父是窗口资源句柄或UI元素资源句柄. 如果是窗口资源句柄将被添加到窗口, 如果是元素资源句柄将被添加到元素.
//
// col_extend_count: 列数量. 例如: 内置模板是1列, 如果数据有5列, 那么此参数填5.
func X创建列表树Ex(元素x坐标, 元素y坐标, 宽度, 高度 int32, 父窗口句柄, 列数量 int32) *X结构_列表树 {
	p := &X结构_列表树{}
	p.X设置句柄(xc.X列表树_创建Ex(元素x坐标, 元素y坐标, 宽度, 高度, 父窗口句柄, 列数量))
	return p
}

// 从句柄创建对象.
func X创建列表树并按句柄(句柄 int) *X结构_列表树 {
	p := &X结构_列表树{}
	p.X设置句柄(句柄)
	return p
}

// 从name创建对象, 失败返回nil.
func X创建列表树并按名称(名称 string) *X结构_列表树 {
	handle := xc.X取对象并按名称(名称)
	if handle > 0 {
		p := &X结构_列表树{}
		p.X设置句柄(handle)
		return p
	}
	return nil
}

// 从UID创建对象, 失败返回nil.
func X创建列表树并按UID(UID int32) *X结构_列表树 {
	handle := xc.X取对象并按UID(UID)
	if handle > 0 {
		p := &X结构_列表树{}
		p.X设置句柄(handle)
		return p
	}
	return nil
}

// 从UID名称创建对象, 失败返回nil.
func X创建列表树并按UID名称(名称 string) *X结构_列表树 {
	handle := xc.X取对象并按UID名称(名称)
	if handle > 0 {
		p := &X结构_列表树{}
		p.X设置句柄(handle)
		return p
	}
	return nil
}

// 列表树_启用拖动项, 启用拖动项功能.
//
// bEnable: 是否启用.
func (t *X结构_列表树) X启用拖动项(是否启用 bool) *X结构_列表树 {
	xc.X列表树_启用拖动项(t.X句柄, 是否启用)
	return t
}

// 列表树_启用连接线, 启用或禁用显示项的连接线.
//
// bEnable: 是否启用.
//
// bSolid: 实线或虚线; TRUE: 实线, FALSE: 虚线.
func (t *X结构_列表树) X启用连接线(是否启用 bool, 实线或虚线 bool) *X结构_列表树 {
	xc.X列表树_启用连接线(t.X句柄, 是否启用, 实线或虚线)
	return t
}

// 列表树_启用展开, 启动或关闭默认展开功能, 如果开启新插入的项将自动展开.
//
// bEnable: 是否启用.
func (t *X结构_列表树) X启用展开(是否启用 bool) *X结构_列表树 {
	xc.X列表树_启用展开(t.X句柄, 是否启用)
	return t
}

// 列表树_启用模板复用.
//
// bEnable: 是否启用.
func (t *X结构_列表树) X启用模板复用(是否启用 bool) *X结构_列表树 {
	xc.X列表树_启用模板复用(t.X句柄, 是否启用)
	return t
}

// 列表树_置连接线颜色.
//
// color: xc.RGBA 颜色.
func (t *X结构_列表树) X设置连接线颜色(ABGR颜色 int) *X结构_列表树 {
	xc.X列表树_设置连接线颜色(t.X句柄, ABGR颜色)
	return t
}

// 列表树_置展开按钮大小, 设置展开按钮占用空间大小.
//
// nWidth: 宽度.
//
// nHeight: 高度.
func (t *X结构_列表树) X设置展开按钮大小(宽度, 高度 int32) *X结构_列表树 {
	xc.X列表树_设置展开按钮大小(t.X句柄, 宽度, 高度)
	return t
}

// 列表树_置连接线长度, 设置连线绘制长度, 展开按钮与项内容之间的连线.
//
// nLength: 连线绘制长度.
func (t *X结构_列表树) X设置连接线长度(长度 int32) *X结构_列表树 {
	xc.X列表树_设置连接线长度(t.X句柄, 长度)
	return t
}

// 列表树_置拖动项插入位置颜色, 设置拖动项插入位置颜色提示.
//
// color: xc.RGBA 颜色.
func (t *X结构_列表树) X设置拖动项插入位置颜色(ABGR颜色 int) *X结构_列表树 {
	xc.X列表树_设置拖动项插入位置颜色(t.X句柄, ABGR颜色)
	return t
}

// 列表树_置项模板文件.
//
// pXmlFile: 文件名.
func (t *X结构_列表树) X设置项模板文件(文件名 string) bool {
	return xc.X列表树_设置项模板文件(t.X句柄, 文件名)
}

// 列表树_置选择项模板文件, 设置项模板文件, 项选中状态.
//
// pXmlFile: 文件名.
func (t *X结构_列表树) X设置选择项模板文件(文件名 string) bool {
	return xc.X列表树_设置选择项模板文件(t.X句柄, 文件名)
}

// 列表树_置项模板.
//
// hTemp: 模板句柄.
func (t *X结构_列表树) X设置项模板(模板句柄 int) bool {
	return xc.X列表树_设置项模板(t.X句柄, 模板句柄)
}

// 列表树_置选择项模板, 设置列表项模板, 项选中状态.
//
// hTemp: 模板句柄.
func (t *X结构_列表树) X设置选择项模板(模板句柄 int) bool {
	return xc.X列表树_设置选择项模板(t.X句柄, 模板句柄)
}

// 列表树_置项模板从字符串, 设置项模板文件.
//
// pStringXML: 字符串.
func (t *X结构_列表树) X设置项模板并按文本(xml文本 string) bool {
	return xc.X列表树_设置项模板从文本(t.X句柄, xml文本)
}

// 列表树_置选择项模板从字符串, 设置项模板文件, 项选中状态.
//
// pStringXML: 字符串.
func (t *X结构_列表树) X设置选择项模板并按文本(xml文本 string) bool {
	return xc.X列表树_设置选择项模板从文本(t.X句柄, xml文本)
}

// 列表树_置项背景绘制标志, 设置是否绘制指定状态下项的背景.
//
// nFlags: 标志位: xcc.List_DrawItemBk_Flag_.
func (t *X结构_列表树) X设置项背景绘制标志(标志位 xcc.X项背景绘制标识) *X结构_列表树 {
	xc.X列表树_设置项背景绘制标志(t.X句柄, 标志位)
	return t
}

// 列表树_置项数据, 设置项用户数据.
//
// nID: 项ID.
//
// nUserData: 用户数据.
func (t *X结构_列表树) X设置项数据(项ID int32, 用户数据 int) bool {
	return xc.X列表树_设置项数据(t.X句柄, 项ID, 用户数据)
}

// 列表树_取项数据, 获取项用户数据.
//
// nID: 项ID.
func (t *X结构_列表树) X取项数据(项ID int32) int {
	return xc.X列表树_取项数据(t.X句柄, 项ID)
}

// 列表树_置选择项.
//
// nID: 项ID.
func (t *X结构_列表树) X设置选择项(项ID int32) bool {
	return xc.X列表树_设置选择项(t.X句柄, 项ID)
}

// 列表树_取选择项, 返回项ID.
func (t *X结构_列表树) X取选择项() int32 {
	return xc.X列表树_取选择项(t.X句柄)
}

// 列表树_可视指定项, 滚动视图让指定项可见.
//
// nID: 项索引.
func (t *X结构_列表树) X可视指定项(项索引 int32) *X结构_列表树 {
	xc.X列表树_可视指定项(t.X句柄, 项索引)
	return t
}

// 列表树_判断展开.
//
// nID: 项ID.
func (t *X结构_列表树) X判断展开(项ID int32) bool {
	return xc.X列表树_判断展开(t.X句柄, 项ID)
}

// 列表树_展开项, 判断项是否展开.
//
// nID: 项ID.
//
// bExpand: 是否展开.
func (t *X结构_列表树) X展开项(项ID int32, 是否展开 bool) bool {
	return xc.X列表树_展开项(t.X句柄, 项ID, 是否展开)
}

// 列表树_展开全部子项, 展开所有的子项.
//
// nID: 项ID.
//
// bExpand: 是否展开.
func (t *X结构_列表树) X展开全部子项(项ID int32, 是否展开 bool) bool {
	return xc.X列表树_展开全部子项(t.X句柄, 项ID, 是否展开)
}

// 列表树_测试点击项, 检测坐标点所在项, 返回项ID.
//
// pPt: 坐标点.
func (t *X结构_列表树) X测试点击项(坐标点 *xc.X结构_坐标) int32 {
	return xc.X列表树_测试点击项(t.X句柄, 坐标点)
}

// 列表树_测试点击项扩展, 检测坐标点所在项, 自动添加滚动视图偏移坐标, 返回项ID.
//
// pPt: 坐标点.
func (t *X结构_列表树) X测试点击项EX(坐标点 *xc.X结构_坐标) int32 {
	return xc.X列表树_测试点击项EX(t.X句柄, 坐标点)
}

// 列表树_取第一个子项, 获取第一个子项. 成功返回项ID, 失败返回XC_ID_ERROR.
//
// nID: 项ID.
func (t *X结构_列表树) X取第一个子项(项ID int32) int32 {
	return xc.X列表树_取第一个子项(t.X句柄, 项ID)
}

// 列表树_取末尾子项, 获取末尾子项. 成功返回项ID, 失败返回XC_ID_ERROR.
//
// nID: 项ID.
func (t *X结构_列表树) X取末尾子项(项ID int32) int32 {
	return xc.X列表树_取末尾子项(t.X句柄, 项ID)
}

// 列表树_取上一个兄弟项, 成功返回项ID, 失败返回XC_ID_ERROR.
//
// nID: 项ID.
func (t *X结构_列表树) X取上一个兄弟项(项ID int32) int32 {
	return xc.X列表树_取上一个兄弟项(t.X句柄, 项ID)
}

// 列表树_取下一个兄弟项, 成功返回项ID, 失败返回XC_ID_ERROR.
//
// nID: 项ID.
func (t *X结构_列表树) X取下一个兄弟项(项ID int32) int32 {
	return xc.X列表树_取下一个兄弟项(t.X句柄, 项ID)
}

// 列表树_取父项, 成功返回项ID, 失败返回XC_ID_ERROR.
//
// nID: 项ID.
func (t *X结构_列表树) X取父项(项ID int32) int32 {
	return xc.X列表树_取父项(t.X句柄, 项ID)
}

// 列表树_创建数据适配器, 创建数据适配器，根据绑定的项模板初始化数据适配器的列, 返回适配器句柄.
func (t *X结构_列表树) X创建数据适配器() int {
	return xc.X列表树_创建数据适配器(t.X句柄)
}

// 列表树_绑定数据适配器.
//
// hAdapter: 数据适配器句柄, XAdTree.
func (t *X结构_列表树) X绑定数据适配器(数据适配器句柄 int) *X结构_列表树 {
	xc.X列表树_绑定数据适配器(t.X句柄, 数据适配器句柄)
	return t
}

// 列表树_取数据适配器, 返回数据适配器句柄.
func (t *X结构_列表树) X取数据适配器() int {
	return xc.X列表树_取数据适配器(t.X句柄)
}

// 列表树_刷新数据, 刷新所有项模板, 以便更新UI.
func (t *X结构_列表树) X刷新数据() *X结构_列表树 {
	xc.X列表树_刷新数据(t.X句柄)
	return t
}

// 列表树_刷新指定项, 刷新指定项模板, 以便更新UI.
//
// nID: 项ID.
func (t *X结构_列表树) X刷新指定项(项ID int32) *X结构_列表树 {
	xc.X列表树_刷新指定项(t.X句柄, 项ID)
	return t
}

// 列表树_置缩进, 设置缩进大小.
//
// nWidth: 缩进宽度.
func (t *X结构_列表树) X设置缩进(缩进宽度 int32) *X结构_列表树 {
	xc.X列表树_设置缩进(t.X句柄, 缩进宽度)
	return t
}

// 列表树_取缩进, 返回缩进值大小.
func (t *X结构_列表树) X取缩进() int32 {
	return xc.X列表树_取缩进(t.X句柄)
}

// 列表树_置项默认高度.
//
// nHeight: 高度.
//
// nSelHeight: 选中时高度.
func (t *X结构_列表树) X设置项默认高度(高度, 选中时高度 int32) *X结构_列表树 {
	xc.X列表树_设置项默认高度(t.X句柄, 高度, 选中时高度)
	return t
}

// 列表树_取项默认高度.
//
// pHeight: 接收返回高度.
//
// pSelHeight: 接收返回值, 当项选中时的高度.
func (t *X结构_列表树) X取项默认高度(返回高度, 返回选中时高度 *int32) *X结构_列表树 {
	xc.X列表树_取项默认高度(t.X句柄, 返回高度, 返回选中时高度)
	return t
}

// 列表树_置项高度.
//
// nID: 项ID.
//
// nHeight: 高度.
//
// nSelHeight: 选中时高度.
func (t *X结构_列表树) X设置项高度(项ID, 高度, 选中时高度 int32) *X结构_列表树 {
	xc.X列表树_设置项高度(t.X句柄, 项ID, 高度, 选中时高度)
	return t
}

// 列表树_取项高度.
//
// nID: 项ID.
//
// pHeight: 接收返回高度.
//
// pSelHeight: 接收返回值, 当项选中时的高度.
func (t *X结构_列表树) X取项高度(项ID int32, 返回高度, 返回选中时高度 *int32) *X结构_列表树 {
	xc.X列表树_取项高度(t.X句柄, 项ID, 返回高度, 返回选中时高度)
	return t
}

// 列表树_置行间距.
//
// nSpace: 行间隔大小.
func (t *X结构_列表树) X设置行间距(行间隔大小 int32) *X结构_列表树 {
	xc.X列表树_设置行间距(t.X句柄, 行间隔大小)
	return t
}

// 列表树_取行间距.
func (t *X结构_列表树) X取行间距() int32 {
	return xc.X列表树_取行间距(t.X句柄)
}

// 列表树_移动项, 移动项的位置.
//
// nMoveItem: 要移动的项ID.
//
// nDestItem: 目标项ID, 参照位置.
//
// nFlag: 0:目标前面, 1:目标后面, 2:目标子项首, 3:目标子项尾.
func (t *X结构_列表树) X移动项(要移动的项ID, 目标项ID, 位置 int32) bool {
	return xc.X列表树_移动项(t.X句柄, 要移动的项ID, 目标项ID, 位置)
}

// 列表树_取模板对象, 通过模板项ID, 获取实例化模板项ID对应的对象句柄.
//
// nID: 树项ID.
//
// nTempItemID: 模板项ID.
func (t *X结构_列表树) X取模板对象(项ID, 模板项ID int32) int {
	return xc.X列表树_取模板对象(t.X句柄, 项ID, 模板项ID)
}

// 列表树_取对象所在项, 获取当前对象所在模板实例, 属于列表树中哪一个项. 成功返回项ID, 否则返回XC_ID_ERROR.
//
// hXCGUI: 对象句柄.
func (t *X结构_列表树) X取对象所在项(对象句柄 int) int32 {
	return xc.X列表树_取对象所在项(t.X句柄, 对象句柄)
}

// 列表树_插入项文本.
//
// pValue:.
//
// nParentID:.
//
// insertID:.
func (t *X结构_列表树) X插入项文本(值 string, 父id, 插入id int32) int32 {
	return xc.X列表树_插入项文本(t.X句柄, 值, 父id, 插入id)
}

// 列表树_插入项文本扩展.
//
// pName:.
//
// pValue:.
//
// nParentID:.
//
// insertID:.
func (t *X结构_列表树) X插入项文本EX(名称 string, 值 string, 父id, 插入id int32) int32 {
	return xc.X列表树_插入项文本EX(t.X句柄, 名称, 值, 父id, 插入id)
}

// 列表树_插入项图片.
//
// hImage:.
//
// nParentID:.
//
// insertID:.
func (t *X结构_列表树) X插入项图片(图片 int, 父id, 插入id int32) int32 {
	return xc.X列表树_插入项图片(t.X句柄, 图片, 父id, 插入id)
}

// 列表树_插入项图片扩展.
//
// pName:.
//
// hImage:.
//
// nParentID:.
//
// insertID:.
func (t *X结构_列表树) X插入项图片EX(名称 string, 图片 int, 父id, 插入id int32) int32 {
	return xc.X列表树_插入项图片EX(t.X句柄, 名称, 图片, 父id, 插入id)
}

// 列表树_取项数量.
func (t *X结构_列表树) X取项数量() int32 {
	return xc.X列表树_取项数量(t.X句柄)
}

// 列表树_取列数量.
func (t *X结构_列表树) X取列数量() int32 {
	return xc.X列表树_取列数量(t.X句柄)
}

// 列表树_置项文本.
//
// nID:.
//
// iColumn:.
//
// pValue:.
func (t *X结构_列表树) X设置项文本(项ID, 列 int32, 值 string) bool {
	return xc.X列表树_设置项文本(t.X句柄, 项ID, 列, 值)
}

// 列表树_置项文本扩展.
//
// nID:.
//
// pName:.
//
// pValue:.
func (t *X结构_列表树) X设置项文本EX(项ID int32, 名称 string, 值 string) bool {
	return xc.X列表树_设置项文本EX(t.X句柄, 项ID, 名称, 值)
}

// 列表树_置项图片.
//
// nID:.
//
// iColumn:.
//
// hImage:.
func (t *X结构_列表树) X设置项图片(项ID, 列 int32, 图片 int) bool {
	return xc.X列表树_设置项图片(t.X句柄, 项ID, 列, 图片)
}

// 列表树_置项图片扩展.
//
// nID:.
//
// pName:.
//
// hImage:.
func (t *X结构_列表树) X设置项图片EX(项ID int32, 名称 string, 图片 int) bool {
	return xc.X列表树_设置项图片EX(t.X句柄, 项ID, 名称, 图片)
}

// 列表树_取项文本.
//
// nID:.
//
// iColumn:.
func (t *X结构_列表树) X取项文本(项ID, 列 int32) string {
	return xc.X列表树_取项文本(t.X句柄, 项ID, 列)
}

// 列表树_取项文本扩展.
//
// nID:.
//
// pName:.
func (t *X结构_列表树) X取项文本EX(项ID int32, 名称 string) string {
	return xc.X列表树_取项文本EX(t.X句柄, 项ID, 名称)
}

// 列表树_取项图片.
//
// nID:.
//
// iColumn:.
func (t *X结构_列表树) X取项图片(项ID, 列 int32) int {
	return xc.X列表树_取项图片(t.X句柄, 项ID, 列)
}

// 列表树_取项图片扩展.
//
// nID:.
//
// pName:.
func (t *X结构_列表树) X取项图片EX(项ID int32, 名称 string) int {
	return xc.X列表树_取项图片EX(t.X句柄, 项ID, 名称)
}

// 列表树_删除项.
//
// nID:.
func (t *X结构_列表树) X删除项(nID int32) bool {
	return xc.X列表树_删除项(t.X句柄, nID)
}

// 列表树_删除全部项.
func (t *X结构_列表树) X删除全部项() *X结构_列表树 {
	xc.X列表树_删除全部项(t.X句柄)
	return t
}

// 列表树_删除列全部.
func (t *X结构_列表树) X删除列全部() *X结构_列表树 {
	xc.X列表树_删除列全部(t.X句柄)
	return t
}

// 列表树_置分割线颜色.
//
// color: xc.RGBA 颜色值.
func (t *X结构_列表树) X设置分割线颜色(ABGR颜色值 int) *X结构_列表树 {
	xc.X列表树_设置分割线颜色(t.X句柄, ABGR颜色值)
	return t
}

// 列表树_置项模板从内存.
//
// data: 模板数据.
func (t *X结构_列表树) X设置项模板从内存(模板数据 []byte) bool {
	return xc.X列表树_设置项模板从内存(t.X句柄, 模板数据)
}

// 列表树_置项模板从资源ZIP.
//
// id: RC资源ID.
//
// pFileName: 文件名.
//
// pPassword: zip密码.
//
// hModule: 模块句柄, 可填0.
func (t *X结构_列表树) X设置项模板并按资源zip(RC资源ID int32, 文件名 string, zip密码 string, 模块句柄 uintptr) bool {
	return xc.X列表树_设置项模板从资源zip(t.X句柄, RC资源ID, 文件名, zip密码, 模块句柄)
}

// 列表树_取项模板, 返回项模板句柄.
func (t *X结构_列表树) X取项模板() int {
	return xc.X列表树_取项模板(t.X句柄)
}

// ------------------------- 事件 ------------------------- //

// 列表树元素-项模板创建,模板复用机制需先启用; 替换模板无效判断nFlag,因为内部会检查模板是否改变,不用担心重复.
//
// nFlag  0:状态改变; 1:新模板实例; 2:旧模板复用
type X事件_列表树_项模板创建 func(pItem *xc.X结构_列表树项, nFlag int32, pbHandled *bool) int

// 列表树元素-项模板创建,模板复用机制需先启用; 替换模板无效判断nFlag,因为内部会检查模板是否改变,不用担心重复.
//
// nFlag  0:状态改变; 1:新模板实例; 2:旧模板复用
type X事件_列表树_项模板创建1 func(hEle int, pItem *xc.X结构_列表树项, nFlag int32, pbHandled *bool) int

// 列表树元素-项模板创建完成,模板复用机制需先启用; 不管是新建还是复用,都需要更新数据, 当为复用时不要注册事件以免重复注册.
//
// nFlag  0:状态改变(复用); 1:新模板实例; 2:旧模板复用
type X事件_列表树_项模板创建完成 func(pItem *xc.X结构_列表树项, nFlag int32, pbHandled *bool) int

// 列表树元素-项模板创建完成,模板复用机制需先启用; 不管是新建还是复用,都需要更新数据, 当为复用时不要注册事件以免重复注册.
//
// nFlag  0:状态改变(复用); 1:新模板实例; 2:旧模板复用
type X事件_列表树_项模板创建完成1 func(hEle int, pItem *xc.X结构_列表树项, nFlag int32, pbHandled *bool) int

// 列表树元素-项模板销毁,模板复用机制需先启用;
//
// nFlag   0:正常销毁;  1:移动到缓存(不会被销毁,临时缓存备用,当需要时被复用)
type X事件_列表树_项模板销毁 func(pItem *xc.X结构_列表树项, nFlag int32, pbHandled *bool) int

// 列表树元素-项模板销毁,模板复用机制需先启用;
//
// nFlag   0:正常销毁;  1:移动到缓存(不会被销毁,临时缓存备用,当需要时被复用)
type X事件_列表树_项模板销毁1 func(hEle int, pItem *xc.X结构_列表树项, nFlag int32, pbHandled *bool) int
type X事件_列表树_项模板 func(pItem *xc.X结构_列表树项, pbHandled *bool) int            // 树元素,项模板,调整项坐标. 已停用.
type X事件_列表树_项模板1 func(hEle int, pItem *xc.X结构_列表树项, pbHandled *bool) int // 树元素,项模板,调整项坐标. 已停用.
type X事件_列表树_绘制项 func(hDraw int, pItem *xc.X结构_列表树项, pbHandled *bool) int               // 树元素,绘制项.
type X事件_列表树_绘制项1 func(hEle int, hDraw int, pItem *xc.X结构_列表树项, pbHandled *bool) int    // 树元素,绘制项.
type X事件_列表树_项选择 func(nItemID int32, pbHandled *bool) int                                   // 树元素,项选择事件.
type X事件_列表树_项选择1 func(hEle int, nItemID int32, pbHandled *bool) int                        // 树元素,项选择事件.
type X事件_列表树_项展开收缩 func(id int32, bExpand bool, pbHandled *bool) int                          // 树元素,项展开收缩事件.
type X事件_列表树_项展开收缩1 func(hEle int, id int32, bExpand bool, pbHandled *bool) int               // 树元素,项展开收缩事件.
type X事件_列表树_用户正在拖动项 func(pInfo *xc.X结构_列表树UI元素拖动项, pbHandled *bool) int                // 树元素,用户正在拖动项, 可对参数值修改.
type X事件_列表树_用户正在拖动项1 func(hEle int, pInfo *xc.X结构_列表树UI元素拖动项, pbHandled *bool) int     // 树元素,用户正在拖动项, 可对参数值修改.
type X事件_列表树_拖动项 func(pInfo *xc.X结构_列表树UI元素拖动项, pbHandled *bool) int                    // 树元素,拖动项事件.
type X事件_列表树_拖动项1 func(hEle int, pInfo *xc.X结构_列表树UI元素拖动项, pbHandled *bool) int         // 树元素,拖动项事件.

// 列表树元素-项模板创建,模板复用机制需先启用; 替换模板无效判断nFlag,因为内部会检查模板是否改变,不用担心重复.
//
// nFlag  0:状态改变; 1:新模板实例; 2:旧模板复用
func (t *X结构_列表树) X事件_项模板创建(回调函数 X事件_列表树_项模板创建) bool {
	return xc.X元素_注册事件C(t.X句柄, xcc.X元素事件_列表树_项模板创建, 回调函数)
}

// 列表树元素-项模板创建,模板复用机制需先启用; 替换模板无效判断nFlag,因为内部会检查模板是否改变,不用担心重复.
//
// nFlag  0:状态改变; 1:新模板实例; 2:旧模板复用
func (t *X结构_列表树) X事件_项模板创建1(回调函数 X事件_列表树_项模板创建1) bool {
	return xc.X元素_注册事件C1(t.X句柄, xcc.X元素事件_列表树_项模板创建, 回调函数)
}

// 列表树元素-项模板创建完成,模板复用机制需先启用; 不管是新建还是复用,都需要更新数据, 当为复用时不要注册事件以免重复注册.
//
// nFlag  0:状态改变(复用); 1:新模板实例; 2:旧模板复用
func (t *X结构_列表树) X事件_项模板创建完成(回调函数 X事件_列表树_项模板创建完成) bool {
	return xc.X元素_注册事件C(t.X句柄, xcc.X元素事件_列表树_项模板创建完成, 回调函数)
}

// 列表树元素-项模板创建完成,模板复用机制需先启用; 不管是新建还是复用,都需要更新数据, 当为复用时不要注册事件以免重复注册.
//
// nFlag  0:状态改变(复用); 1:新模板实例; 2:旧模板复用
func (t *X结构_列表树) X事件_项模板创建完成1(回调函数 X事件_列表树_项模板创建完成1) bool {
	return xc.X元素_注册事件C1(t.X句柄, xcc.X元素事件_列表树_项模板创建完成, 回调函数)
}

// 列表树元素-项模板销毁,模板复用机制需先启用;
//
// nFlag   0:正常销毁;  1:移动到缓存(不会被销毁,临时缓存备用,当需要时被复用)
func (t *X结构_列表树) X事件_项模板销毁(回调函数 X事件_列表树_项模板销毁) bool {
	return xc.X元素_注册事件C(t.X句柄, xcc.X元素事件_列表树_项模板销毁, 回调函数)
}

// 列表树元素-项模板销毁,模板复用机制需先启用;
//
// nFlag   0:正常销毁;  1:移动到缓存(不会被销毁,临时缓存备用,当需要时被复用)
func (t *X结构_列表树) X事件_项模板销毁1(回调函数 X事件_列表树_项模板销毁1) bool {
	return xc.X元素_注册事件C1(t.X句柄, xcc.X元素事件_列表树_项模板销毁, 回调函数)
}

// 树元素,项模板,调整项坐标. 已停用.
func (t *X结构_列表树) X停用_项模板(回调函数 X事件_列表树_项模板) bool {
	return xc.X元素_注册事件C(t.X句柄, xcc.X元素事件_树_调整项坐标_已停用, 回调函数)
}

// 树元素,项模板,调整项坐标. 已停用.
func (t *X结构_列表树) X停用_项模板1(回调函数 X事件_列表树_项模板1) bool {
	return xc.X元素_注册事件C1(t.X句柄, xcc.X元素事件_树_调整项坐标_已停用, 回调函数)
}

// 树元素,绘制项.
func (t *X结构_列表树) X事件_绘制项(回调函数 X事件_列表树_绘制项) bool {
	return xc.X元素_注册事件C(t.X句柄, xcc.X元素事件_树_绘制项, 回调函数)
}

// 树元素,绘制项.
func (t *X结构_列表树) X事件_绘制项1(回调函数 X事件_列表树_绘制项1) bool {
	return xc.X元素_注册事件C1(t.X句柄, xcc.X元素事件_树_绘制项, 回调函数)
}

// 树元素,项选择事件.
func (t *X结构_列表树) X事件_项选择(回调函数 X事件_列表树_项选择) bool {
	return xc.X元素_注册事件C(t.X句柄, xcc.X元素事件_树_项选择, 回调函数)
}

// 树元素,项选择事件.
func (t *X结构_列表树) X事件_项选择1(回调函数 X事件_列表树_项选择1) bool {
	return xc.X元素_注册事件C1(t.X句柄, xcc.X元素事件_树_项选择, 回调函数)
}

// 树元素,项展开收缩事件.
func (t *X结构_列表树) X事件_项展开收缩(回调函数 X事件_列表树_项展开收缩) bool {
	return xc.X元素_注册事件C(t.X句柄, xcc.X元素事件_树_项展开收缩, 回调函数)
}

// 树元素,项展开收缩事件.
func (t *X结构_列表树) X事件_项展开收缩1(回调函数 X事件_列表树_项展开收缩1) bool {
	return xc.X元素_注册事件C1(t.X句柄, xcc.X元素事件_树_项展开收缩, 回调函数)
}

// 树元素,用户正在拖动项, 可对参数值修改.
func (t *X结构_列表树) X事件_用户正在拖动项(回调函数 X事件_列表树_用户正在拖动项) bool {
	return xc.X元素_注册事件C(t.X句柄, xcc.X元素事件_树_用户正在拖动项, 回调函数)
}

// 树元素,用户正在拖动项, 可对参数值修改.
func (t *X结构_列表树) X事件_用户正在拖动项1(回调函数 X事件_列表树_用户正在拖动项1) bool {
	return xc.X元素_注册事件C1(t.X句柄, xcc.X元素事件_树_用户正在拖动项, 回调函数)
}

// 树元素,拖动项事件.
func (t *X结构_列表树) X事件_拖动项(回调函数 X事件_列表树_拖动项) bool {
	return xc.X元素_注册事件C(t.X句柄, xcc.X元素事件_树_拖动项, 回调函数)
}

// 树元素,拖动项事件.
func (t *X结构_列表树) X事件_拖动项1(回调函数 X事件_列表树_拖动项1) bool {
	return xc.X元素_注册事件C1(t.X句柄, xcc.X元素事件_树_拖动项, 回调函数)
}

// ------------------------- AddEvent ------------------------- //

// AddEvent_Tree_Temp_Create 添加列表树元素-项模板创建事件, 模板复用机制需先启用. 替换模板无效判断 nFlag, 因为内部会检查模板是否改变, 不用担心重复.
//   - nFlag: 0: 状态改变; 1: 新模板实例; 2: 旧模板复用
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (t *X结构_列表树) AddEvent_Tree_Temp_Create(pFun X事件_列表树_项模板创建1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(t.X句柄, xcc.X元素事件_列表树_项模板创建, onXE_TREE_TEMP_CREATE, pFun, allowAddingMultiple...)
}

// onXE_TREE_TEMP_CREATE 列表树元素-项模板创建事件, 模板复用机制需先启用.
func onXE_TREE_TEMP_CREATE(hEle int, pItem *xc.X结构_列表树项, nFlag int32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表树_项模板创建)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表树_项模板创建1)(hEle, pItem, nFlag, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Tree_Temp_Create_End 添加列表树元素-项模板创建完成事件, 模板复用机制需先启用. 不管是新建还是复用,都需要更新数据, 当为复用时不要注册事件以免重复注册.
//   - nFlag: 0: 状态改变(复用); 1: 新模板实例; 2: 旧模板复用
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (t *X结构_列表树) AddEvent_Tree_Temp_Create_End(pFun X事件_列表树_项模板创建完成1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(t.X句柄, xcc.X元素事件_列表树_项模板创建完成, onXE_TREE_TEMP_CREATE_END, pFun, allowAddingMultiple...)
}

// onXE_TREE_TEMP_CREATE_END 列表树元素-项模板创建完成事件, 模板复用机制需先启用.
func onXE_TREE_TEMP_CREATE_END(hEle int, pItem *xc.X结构_列表树项, nFlag int32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表树_项模板创建完成)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表树_项模板创建完成1)(hEle, pItem, nFlag, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Tree_Temp_Destroy 添加列表树元素-项模板销毁事件, 模板复用机制需先启用.
//   - nFlag: 0: 正常销毁; 1: 移动到缓存(不会被销毁, 临时缓存备用, 当需要时被复用)
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (t *X结构_列表树) AddEvent_Tree_Temp_Destroy(pFun X事件_列表树_项模板销毁1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(t.X句柄, xcc.X元素事件_列表树_项模板销毁, onXE_TREE_TEMP_DESTROY, pFun, allowAddingMultiple...)
}

// onXE_TREE_TEMP_DESTROY 列表树元素-项模板销毁事件, 模板复用机制需先启用.
func onXE_TREE_TEMP_DESTROY(hEle int, pItem *xc.X结构_列表树项, nFlag int32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_列表树_项模板销毁)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表树_项模板销毁1)(hEle, pItem, nFlag, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Tree_Temp_Adjust_Coordinate 添加树元素-项模板-调整项坐标事件. 已停用.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (t *X结构_列表树) AddEvent_Tree_Temp_Adjust_Coordinate(pFun X事件_列表树_项模板1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(t.X句柄, xcc.X元素事件_树_调整项坐标_已停用, onXE_TREE_TEMP_ADJUST_COORDINATE, pFun, allowAddingMultiple...)
}

// onXE_TREE_TEMP_ADJUST_COORDINATE 树元素-项模板-调整项坐标事件. 已停用.
func onXE_TREE_TEMP_ADJUST_COORDINATE(hEle int, pItem *xc.X结构_列表树项, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_树_调整项坐标_已停用)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表树_项模板1)(hEle, pItem, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Tree_DrawItem 添加树元素-绘制项事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (t *X结构_列表树) AddEvent_Tree_DrawItem(pFun X事件_列表树_绘制项1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(t.X句柄, xcc.X元素事件_树_绘制项, onXE_TREE_DRAWITEM, pFun, allowAddingMultiple...)
}

// onXE_TREE_DRAWITEM 树元素-绘制项事件.
func onXE_TREE_DRAWITEM(hEle int, hDraw int, pItem *xc.X结构_列表树项, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_树_绘制项)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表树_绘制项1)(hEle, hDraw, pItem, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Tree_Select 添加树元素-项选择事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (t *X结构_列表树) AddEvent_Tree_Select(pFun X事件_列表树_项选择1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(t.X句柄, xcc.X元素事件_树_项选择, onXE_TREE_SELECT, pFun, allowAddingMultiple...)
}

// onXE_TREE_SELECT 树元素-项选择事件.
func onXE_TREE_SELECT(hEle int, nItemID int32, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_树_项选择)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表树_项选择1)(hEle, nItemID, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Tree_Expand 添加树元素-项展开收缩事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (t *X结构_列表树) AddEvent_Tree_Expand(pFun X事件_列表树_项展开收缩1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(t.X句柄, xcc.X元素事件_树_项展开收缩, onXE_TREE_EXPAND, pFun, allowAddingMultiple...)
}

// onXE_TREE_EXPAND 树元素-项展开收缩事件.
func onXE_TREE_EXPAND(hEle int, id int32, bExpand bool, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_树_项展开收缩)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表树_项展开收缩1)(hEle, id, bExpand, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Tree_Drag_Item_Ing 添加树元素-用户正在拖动项事件, 可对参数值修改.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (t *X结构_列表树) AddEvent_Tree_Drag_Item_Ing(pFun X事件_列表树_用户正在拖动项1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(t.X句柄, xcc.X元素事件_树_用户正在拖动项, onXE_TREE_DRAG_ITEM_ING, pFun, allowAddingMultiple...)
}

// onXE_TREE_DRAG_ITEM_ING 树元素-用户正在拖动项事件.
func onXE_TREE_DRAG_ITEM_ING(hEle int, pInfo *xc.X结构_列表树UI元素拖动项, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_树_用户正在拖动项)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表树_用户正在拖动项1)(hEle, pInfo, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}

// AddEvent_Tree_Drag_Item 添加树元素-拖动项事件.
//
// pFun: 回调函数.
//
// allowAddingMultiple: 允许添加多个回调函数.
func (t *X结构_列表树) AddEvent_Tree_Drag_Item(pFun X事件_列表树_拖动项1, allowAddingMultiple ...bool) int {
	return EventHandler.AddCallBack(t.X句柄, xcc.X元素事件_树_拖动项, onXE_TREE_DRAG_ITEM, pFun, allowAddingMultiple...)
}

// onXE_TREE_DRAG_ITEM 树元素-拖动项事件.
func onXE_TREE_DRAG_ITEM(hEle int, pInfo *xc.X结构_列表树UI元素拖动项, pbHandled *bool) int {
	cbs := EventHandler.GetCallBacks(hEle, xcc.X元素事件_树_拖动项)
	var ret int
	for i := len(cbs) - 1; i >= 0; i-- {
		if cbs[i] != nil {
			ret = cbs[i].(X事件_列表树_拖动项1)(hEle, pInfo, pbHandled)
			if *pbHandled {
				break
			}
		}
	}
	return ret
}
